//
//  Bridge_Pattern.h
//  HelloWorld
//
//  Created by Kevin Tang on 31/12/14.
//  Copyright (c) 2014年 Kevin Tang. All rights reserved.
//
#include <iostream>

#ifndef __HelloWorld__Bridge_Pattern__
#define __HelloWorld__Bridge_Pattern__
//// 参考网址
//// http://www.cnblogs.com/houleixx/archive/2008/02/23/1078877.html
//// http://www.cnblogs.com/cxjchen/p/3156872.html (这个网址的有内存涉漏，看释构)

void test_brigde ();
//公共汽车可以运行在：高速路上，街道，崎岖小路
//小汽车可以运行在：高速路上，街道，崎岖小路
//老爷车可以运行在：高速路上，街道，崎岖小路
//各种车，可以运行在各种路上。也就是说，我可以增加很多车，也可以增加很多路(高架桥，泥泞路，)
//

//桥接模式(结构型设计模式)
namespace CarRunOnRoad {//一个脆弱的设计
    using namespace std;
    
    //这一部分是路在发生变化,有街道路，有高速路
    //路的基类
    class Road
    {
    public:
        virtual void Run()
        {
            cout << "在路上" <<endl;
        }
        
    };
    //在高速路上
    class SpeedWay:public Road
    {
    public:
        virtual void Run()
        {
            cout << "在高速路上" <<endl;
        }
        
    };
    //在市区街道
    class Street:public Road
    {
    public:
        virtual void Run()
        {
            cout<< "在市区街道" <<endl;
        }
    };
    
    //这一部分是汽车发生变化
    //小汽车在高速路上行使
    class CarOnSpeedWay :public SpeedWay
    {
    public:
        virtual void Run()
        {
            cout << "小汽车在高速路上行使"<< endl;
        }
    };
    //公共汽车在高速路上行使
    class BusOnSpeedWay : public SpeedWay
    {
    public:
        virtual void Run()
        {
            cout << "公共汽车在高速路上行使"<< endl;
        }
    };
    
    //小汽车还可以在街道上行使
    class CaronStreetWay: public Street
    {
    public:
        virtual void Run()
        {
            cout << "小汽车还可以在街道上行使"<< endl;
        }
    };
    //公共汽车在街道上行使
    class BusOnStreetWay : public Street
    {
    public:
        virtual void Run()
        {
            cout << "公共汽车在街道上行使"<< endl;
        }
    };
    
}

namespace CarRunOnRoadBridge {
    using namespace std;
    
    //抽象交通工具
    class AbStractVehicle
    {
    public:
        AbStractVehicle(){}
        virtual ~ AbStractVehicle(){//虚释构，当基类指针指向子类对象时，删除基类指针可以保证调用子类的释构方法
            cout << "call ~ AbStractVehicle" <<endl;
        }
        virtual void Run()=0;//纯虚
    };
    
    //抽象路
    class AbStractRoad
    {
    public:
        AbStractRoad(){}
        virtual ~ AbStractRoad(){//虚释构，当基类指针指向子类对象时，删除基类指针可以保证调用子类的释构方法
            cout<<" call ~AbStractRoad" <<endl;
        }
        virtual void Open()=0;//纯虚函数，决定了类是抽象类，不可以进能实例化 表示路开通了
    };
    
    //街道的具体实现
    class StreetRoad:public AbStractRoad
    {
    private:
        
        AbStractVehicle * m_pImpl;
        
    public:
        void Open()
        {
            m_pImpl->Run();
            cout<<"Street Road" <<endl;
        }
        
        StreetRoad(AbStractVehicle * vehicle)
        {
            m_pImpl = vehicle;
        }
        ~ StreetRoad()
        {
            delete m_pImpl;//这里释放具体对象，调用时就不需要调用delete了
            cout << "call ~ StreetRoad()"<<endl;
        }
    };
    
    
    //小汽车的具体实现
    class Car :public AbStractVehicle
    {
    public:
        Car(){}
        ~Car(){
            cout <<" call ~ Car()" <<endl;
        }
        virtual void Run()
        {
            cout << "car run on " ;
        }
    
    };
    //公共汽车
    class Bus:public AbStractVehicle
    {
    public:
        Bus(){}
        ~Bus(){
            cout << " call ~ Bus"<< endl;
        }
        virtual void Run()
        {
            cout << "Bus run on " ;
        }
    };
    
    //高速路具体实现:我们在此增加一条高速路，要使汽车也可以高速路上行使。我们无需要修改car
    class SpeedWay:public AbStractRoad
    {
    private:
        
        AbStractVehicle * m_pImpl;
        
    public:
        void Open()
        {
            m_pImpl->Run();
            cout<<" Speedway Road" <<endl;
        }
        
        SpeedWay(AbStractVehicle * vehicle)
        {
            m_pImpl = vehicle;
        }
        ~ SpeedWay()
        {
            delete m_pImpl;//这里释放具体对象，调用时就不需要调用delete了
            cout << "~ speed way " << endl;
        }
    
    };
   

}








#endif /* defined(__HelloWorld__Bridge_Pattern__) */
